public class Student {
    private String name;//姓名
    private String gender;//性别

    private int age;//年龄

    private double score;//学分

    private static String classRoom="通信22-2";


    //构造代码块：定义在类中的代码块，但是不能加修饰符号，
    //也叫做实例代码块
    //构造代码块一般用于初始化实例成员变量
    {
        this.name="董李阳";
        this.age=19;
        this.gender="男";
        this.score=3.15;
        //
        //this.classRoom="b223";
        //这个是个static修饰的放在此处从不是很妥当
        //也有静态代码块
        //放在哪个里面处理更好
        System.out.println("I am instance init()!");
    }
    static{
        classRoom="B223";
        System.out.println("I am static init()!");
    }
    public Student(){
        //构造方法
        //静态代码块
        //实例代码块--构造代码块

        System.out.println("I am Student init()!");
    }

    //内部类
    //：当一个事务的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务
    //那么最好这个内部的完整结构使用内部类
    //在java中，可以将一个类定义在另一个类或者一个方法的内部
    //前者称为内部类，后者称为外部类
    //内部类也是封装的一种体现
    //
    //

    public static void main(String[] args) {
        //Student stu1= new Student();

        System.out.println("===============");
        Student stu1= new Student();

        Student stu2= new Student();

        //静态代码块不管生成多少个对象，也只会执行一次
        //静态成员变量是类的属性，因此是JVM加载类时，开辟空间并初始化的
        //如果一个类中包含多个静态代码块，在编译代码的时候，百年一起会按照定义的先后
        //实例代码块只有在创建对象时候才会被执行
        //stu.show();
    }
    public static String getClassRoom(){
        //System.out.println(this);
        //无法从静态上下文中引用非静态变量  this

        //
        //age+=1;
        //无法从静态上下文中引用非静态变量age


        //此方法默认有this传参
        //静态方法中不能去调用任何非静态的方法，因为非静态方法有this参数，在静态方法调用时候无法传递this参数

        //静态方法无法重写，不能用来实现多态
        //doClass();
        return classRoom;
    }
    public void show(){

        System.out.println("name:"+name+" age:"+age+" gender:"+gender);
    }


    public static class TestStudent{
        public static void main(String[] args) {
            System.out.println(Student.getClassRoom());
        }
    }


    public Student(String name, String gender, int age, double score){
        this.name=name;
        this.gender=gender;
        this.age=age;
        this.score=score;
    }

    public void doClass(){
        System.out.println("按时上课，不要迟到，如果请假，及时去补");
    }

    public void doHomework(){
        System.out.println("教务系统，完成作业，一旦拖沓，神仙难救");
    }
    public void exam(){
        System.out.println("考试目的，了解学情，人人必考，暴露问题");
    }

    //静态方法的特性
    //1.不属于某个具体的对象，是类方法
    //2.不可以通过对象调用，也可以通过类名，静态方法名（）方式调用，更推荐使用类名来调用
    //3.不能在静态方法中访问任何非静态成员变量

//    public static void main(String[] args) {
//        System.out.println(Student.classRoom);
//        //通过类名直接访问
//        //
//
//
//
//        Student s1=new Student("li leiLei","男",18,3.8);
//        Student s2=new Student("Han MeiMei","女",19,4.0);
//        Student s3=new Student("Jim","男",18,2.6);
//        //也可以通过对象访问，但是是三个对象共享的
//        System.out.println(s1.classRoom);
//        System.out.println(s2.classRoom);
//        System.out.println(s3.classRoom);
//
//        //现在要给他们创建一份共同的属性
//        //教室
//        //这个教室的属性不需要每个人都存储一份
//        //而是需要让所有的学生来共享的
//        //正好在Java中，被static修饰的成员，称之为静态成员，也可以称之为类成员
//        //而不属于某个具体的独享，是所有对象共享的
//        //static修饰成员变量
//        //
//
//
//        //特性：
//        //1.不属于某个具体的对象，是类的属性，是所有对象共享的，不存储在某个对象的空间中
//        //2.既可以通过对象访问，也可以通过类名。访问 ，一般更加推荐使用类名访问
//        //3.类变量存储在方法区中
//        //4.生命周期伴随类的一生（随类的加载而创建，随类的卸载而销毁
//        //
//    }

    //一般一个文件值定义一个类
    //main方法所在的类要用public修饰，（eclipse默认会在public中修饰的去找main
    //
    //public修饰 的类必须要和文件名字相同，并且一个文件只能一个类被修饰

    //定义一个类就i相当于在计算机中定义了一个新类型

    //用类去创建对象的过程，称为类的实例化
    //在Java中常常使用new关键字
    //

    //类似你的类就是在创造物种的过程
    //

    //你去实例化它，就是去给这个物种的具体化
}

